home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / tcp_ip / gracil / twindv21 / twin_at.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-12  |  46.0 KB  |  1,727 lines
  1. /****************************************************************************
  2. *
  3. *            COPYRIGHT 1990,91,92 BY GRACILIS INC.
  4. *
  5. *             623 Palace St.
  6. *             Aurora, Il. 60506
  7. *
  8. *             (708)-801-8800        Office
  9. *             (708)-844-0183        (FAX - Support BBS)
  10. *
  11. * GRACILIS, INC., MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS 
  12. * SOFTWARE FOR ANY PURPOSE.  
  13. *
  14. * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
  15. * 
  16. * Permission is granted for non-commercial use/distribution only, as long as
  17. * this copyright header is included intact and unaltered.
  18. *
  19. ******************************************************************************/
  20.  
  21. /*****************************************************************************
  22. *
  23. *
  24. * File: twin_at.c
  25. *
  26. * Rev : 3.0
  27. *
  28. * Description:    
  29. *
  30. *    This File contains routines that implement PackeTwin 
  31. *    synchronous SCC driver with an interface to KA9Q's TCP/IP suite.
  32. *
  33. *
  34. * Routines: 
  35. *
  36. *    tsync_attach - Performs attach functions for TCP/IP, i.e.
  37. *                   attach the tsync_driver to TCP/IP.
  38. *
  39. *    do_tsync_stat  - Applications' routine for "displaying" the
  40. *                     tsync_driver statistics.
  41. *
  42. *    tsync_ioctl  - Set the IO Control parameters.
  43. *
  44. *
  45. * Revision History:
  46. *
  47. *    Release 2.0        - 9/7/92    First Release of cleaned up Twin driver
  48. *                                with fewer files, and called twin_at instead
  49. *                                of tsync_at
  50. *
  51. *    Release 2.1        - 9/12/92    Fix bug in half-duplex dma mode, which caused
  52. *                                loss of every other receive frame in a multi-
  53. *                                frame transmission.  
  54. */
  55.  
  56.  
  57. #include <stdio.h>
  58. #include <dos.h>
  59. #include "global.h"
  60. #include "config.h"
  61. #include "hardware.h"
  62. #include "mbuf.h"
  63. #include "iface.h"
  64. #include "ax25.h"
  65. #include "trace.h"
  66. #include "netuser.h"
  67. #include "proc.h"
  68. #include "pktdrvr.h"
  69. #include "devparams.h"
  70. #include "z8530.h"
  71. #include "gracilis.h"
  72. #include "twin.h"
  73.  
  74.  
  75. /* If using the Borland stdio library... */
  76. #ifdef    OLD_KA9Q
  77. #else
  78. /* If using the new KA9Q stdio library... */
  79. #define    tprintf    printf
  80. #endif
  81.  
  82.  
  83. /*******************************************************************
  84. *                        TSYNC_ATTACH                              *
  85. *                                                                  *
  86. * File: tsync_at.c                                                 * 
  87. * Rev : 3.0                                                        *
  88. *                                                                  *
  89. ********************************************************************
  90. *
  91. *
  92. * DESCRIPTION: 
  93. * -----------
  94. * Attaches the PackeTwin's synchronous SCC driver to TCP/IP.
  95. *
  96. * ARGUMENTS:
  97. * ---------
  98. *    All argv's are strings
  99. * argv[0]:  hardware type,  "tsync"  
  100. * argv[1]:  "0" = 8530 SCC A  
  101. *           "1" = 8530 SCC B 
  102. * argv[2]:  vector, Interrupt request line #
  103. *
  104. * argv[3]:  IOBASE : base address for PackeTwin default 0x230
  105. *
  106. * argv[4]:  "HDX"  half-duplex
  107. *           "FDX"  full-duplex
  108. *
  109. * argv[5]:  mode, DMA/INTS for channel 1, MUST be INTS
  110. *
  111. * argv[6]:  Dma channel to use for receive...
  112. *           0 = none... 
  113. *           1 = Rx on dma channel 1 and if FULL DUPLEX tx on channel 3
  114. *           3 = Rx on dma channel 3 and if FULL DUPLEX tx on channel 1
  115. *
  116. * argv[7]:  interface label
  117. *
  118. *           This label is provided by the user and the attach uses
  119. *           it in its tprintf's to tell the user which interface
  120. *           is being talked about.
  121. *
  122. * argv[8]:  max receive packet buffer  size in bytes
  123. * argv[9]:  max xmit packet buffer size in bytes
  124. * argv[10]: interface baud rate, e.g, "9600"
  125. * argv[11]: OPTIONAL - clocking options
  126. * argv[12]: OPTIONAL - clocking options
  127. * argv[13]: OPTIONAL - Data Encoding: NRZ/NRZI
  128. * argv[14]: OPTIONAL - IP address - default is Ip_addr
  129. * argv[15]: OPTIONAL - number of RX buffers to pre-allocate
  130. *
  131. * RETURN VALUES:
  132. * -------------
  133. *  0 - success
  134. * -1 - failure, driver not attached and no memory left allocated
  135. *
  136. * GLOBAL INPUTS:
  137. * -------------
  138. *        
  139. * GLOBAL OUTPUTS:
  140. * --------------
  141. *
  142. * FUNCTIONS CALLED:
  143. * ----------------
  144. * tprintf
  145. * calloc
  146. * malloc
  147. * tsync_hwinit
  148. * free
  149. *
  150. * IO:
  151. * --
  152. *
  153. *
  154. ******************************************************************/
  155.  
  156.  
  157.  
  158.                                     /* Extern declaration for the */
  159. extern UNI_DCB    Twin_udcb[];        /* array of universal control */
  160.                                     /* blocks for this driver */
  161.  
  162. /* interrupt handler */
  163. extern INTERRUPT twinvec();
  164.  
  165. extern INTERRUPT (*Twin_oldvec) __ARGS((void)); /* Old vector contents */
  166. extern INTERRUPT (*Twin_handler) __ARGS((void));
  167.  
  168.  
  169. extern    char *Twin_dvr_version;
  170. extern    int Twin_io_base;
  171.  
  172.  
  173. extern    int16    Twin_vector;
  174. extern    int        Twin_cputype;        /* Global to identify the machine type */
  175.                     /* 0 = 8086        */
  176.                     /* 2 = 80286        */
  177.                     /* 3 = 80386        */
  178.  
  179. int
  180. tsync_attach(argc,argv,p)
  181. int argc;            
  182. char *argv[];
  183. void *p;                /* new for NOS */
  184. {
  185.     extern void tsyncvec();
  186.  
  187.     extern struct iface *ifaces;
  188.     char    i_state;
  189.     int32    ipaddr;            /* new for NOS - IP address */
  190.     int    i;
  191.     char    tmpbuf[80];
  192.     register struct iface *intfc_p;
  193.     DCB *dcbp;
  194.     UNI_DCB *udcbp;
  195.     int udcb_dev;
  196.     int16 rbufsize, xbufsize;
  197.     int    rxdmachan,txdmachan;
  198.     struct drv_timer *timer1;
  199.     unsigned char far *cpusig_ptr;    /* ptr to CPU signature byte in rom */
  200.  
  201.     bool    hdxflg,dmaflg;
  202. #ifdef OLD_KA9Q
  203.     struct phdr *hdr;        /* new for NOS - packet header*/
  204. #endif
  205.  
  206.     void tsync_recv(), tsync_txisr(), tsync_rxisr(), tsync_xstatisr();
  207.  
  208.     int32 tsync_ioctl();
  209.     int tsync_send();
  210.     int tsync_output();
  211.     int tsync_stop();
  212.     int tsync_raw();
  213.     int ax_send();
  214.     int ax_output();
  215.  
  216.  
  217.  
  218.     /* Try reading the Machine ID in ROM... */
  219.     cpusig_ptr = (unsigned char *)MK_FP(0xf000,0xfffe);
  220.  
  221.     if((*cpusig_ptr == 0xfc) || (*cpusig_ptr == 0xf8))
  222.                 Twin_cputype = 2;        /* 80286 or better */
  223.         
  224.     else         Twin_cputype = 0;        /* Default to type 8086 */
  225.  
  226.  
  227. #ifdef TSYNC_DEBUG_PRT
  228.     printf("tsync_attach: argument count is %d\n",argc);
  229.     for(i=0;i<argc;i++)
  230.         printf("arg #%d: %s\n",i,argv[i]);
  231.     printf("\n\n");
  232. #endif
  233.  
  234.  
  235.     /* 
  236.      * validate input params 
  237.      */
  238.     if ( argc < 11 )
  239.     {
  240.         tprintf("tsync_attach: too few arguments (%d) \n", argc);
  241.  
  242.         tprintf("tsync <chan> <vec> <iobase> <hdx|fdx> <dma|ints> <rx dmachan>\n");
  243.         tprintf("      <name> <rxsize> <txsize> <speed> [txclk] [rxclk] [nrz|nrzi] \n");
  244.         tprintf("      [ipaddr] [#rxbufs]\n");
  245.         return(1); /* should this be a -1, milt milt */
  246.     }
  247.  
  248.     /* get the PackeTwin device number/address 
  249.      * and validate it for a synchronous driver
  250.      */
  251.     udcb_dev = htoi(argv[1]);        
  252.  
  253.     /* range check device number */
  254.     if ( (udcb_dev < 0) || (udcb_dev > 1) )
  255.     {
  256.         tprintf("tsync_attach error: Channel number %x out of range!\n", udcb_dev);
  257.         return(-1);
  258.     }
  259.  
  260.     udcbp = &Twin_udcb[udcb_dev];    /* dev num is index number!!! */
  261.  
  262.     /* See if already attached */
  263.     if ( udcbp->attached  == TRUE )
  264.     {
  265.         tprintf("tsync_attach error: Channel %s already attached; interface is %s", argv[1], argv[7]); 
  266.         return(-1);
  267.     }
  268.  
  269.  
  270.     if ( if_lookup(argv[7]) != NULLIF )    /* new for NOS */
  271.     {
  272.         tprintf("Interface %s already exists \n", argv[7]);
  273.         return(-1);
  274.     }
  275.  
  276.     Twin_vector = htoi(argv[2]);
  277.  
  278.     if( Twin_vector <= 0 || Twin_vector > 15)
  279.     {
  280.         tprintf("Illegal vector specified: %s\n", argv[2]);
  281.         return(-1);
  282.  
  283.  
  284.     }
  285.  
  286.     if((htoi(argv[3])) >= 0x100)
  287.         Twin_io_base = htoi(argv[3]);
  288.     else
  289.     {
  290.         tprintf("Illegal iobase specified: %s\n", argv[3]);
  291.         return(-1);
  292.     }
  293.  
  294.     if(strcmpi(argv[4],"hdx") == 0) hdxflg = TRUE; 
  295.     else if(strcmpi(argv[4],"fdx") == 0) hdxflg = FALSE;
  296.     else
  297.     {
  298.         tprintf("tsync_attach error: Specified %s instead of \"hdx\" or \"fdx\" for interface %s\n",
  299.             argv[4],argv[7]);
  300.         return(-1);
  301.     }
  302.  
  303.       /* Are we in DMA mode? */
  304.     if (strcmpi(argv[5],"dma") == 0)
  305.     {
  306.             dmaflg = TRUE;
  307.             rxdmachan = htoi(argv[6]);
  308.  
  309.             /* Did they enter a valid dma channel #? */
  310.             if((rxdmachan != 3) && (rxdmachan != 1))
  311.             {
  312.                 /* NO... bad channel # */
  313.                 tprintf("tsync_attach error: Specified dma channel: %d instead of 1 or 3 for interface %s\n",
  314.                 rxdmachan,argv[7]);
  315.                 return(-1);
  316.             }
  317.  
  318.             /* YES valid channel # */
  319.             else
  320.             {
  321.                 if(hdxflg == FALSE)
  322.                 {
  323.                     if(rxdmachan == 1)txdmachan = 3;
  324.                     else    txdmachan = 1;
  325.                 }
  326.                 else txdmachan = rxdmachan;
  327.             }
  328.     }
  329.  
  330.        /* in interrupt mode? */
  331.     else if (strcmpi(argv[5],"ints") == 0)dmaflg = FALSE;
  332.     else
  333.     {
  334.         tprintf("tsync_attach error: Specified %s instead of \"dma\" or \"ints\" for interface %s\n",
  335.             argv[5],argv[7]);
  336.         return(-1);
  337.     }
  338.  
  339.     /* Can't specify DMA for port B */
  340.     if((dmaflg == TRUE) && (udcb_dev != 0))
  341.     {
  342.         tprintf("tsync_attach error: DMA is not supported on channel 1!\n");
  343.         return(-1);
  344.     }
  345.  
  346.     if ( (rbufsize = atoi(argv[8])) == 0 )
  347.     {
  348.         tprintf("tsync_attach error: Receive buffer size error %s, interface %s\n",
  349.             argv[8],argv[7]);
  350.         return(-1);
  351.     }
  352.  
  353.     if ( (xbufsize = atoi(argv[9])) == 0 )
  354.     {
  355.         tprintf("tsync_attach error: Transmit buffer size error %s, interface %s\n",
  356.             argv[9],argv[7]);
  357.         return(-1);
  358.     }
  359.  
  360.  
  361.     /* new for NOS, Set the IP address */
  362.     ipaddr = Ip_addr;            /* default value */
  363.     if ( argc >= 15 )
  364.         ipaddr = resolve(argv[14]);    
  365.     if ( ipaddr == 0 )
  366.     {
  367.         tprintf(Noipaddr);
  368.         return(-1);
  369.     }
  370.  
  371.  
  372.     /* 
  373.      * try to allocate necessary memory 
  374.      */
  375.     intfc_p = (struct iface *)calloc(1,sizeof(struct iface));
  376.     if ( intfc_p !=  (struct iface *)NULLBUF )
  377.     {
  378.         intfc_p->name = malloc((unsigned int)strlen(argv[7])+2);
  379.         if (intfc_p->name != (char *)NULLBUF )    
  380.         {
  381.             /*  device hw addr  */
  382.             intfc_p->hwaddr = malloc(AXALEN);
  383.             if ( intfc_p->hwaddr == NULLCHAR )
  384.             {
  385.                 free(intfc_p->name);
  386.                 free(intfc_p);
  387.                 tprintf("tsync_attach error: no memory for interface hwaddr, size of sizeof(struct mycall) bytes, interface %s", argv[7]);
  388.                 return(-1);
  389.             }
  390.  
  391.         }
  392.         else
  393.         {
  394.             free(intfc_p);
  395.             tprintf("tsync_attach error: no memory for interface name, size 7 bytes, interface %s", argv[7]);
  396.             return(-1);
  397.         }
  398.     }
  399.     else
  400.     {
  401.         tprintf("tsync_attach error: no memory for interface struct, size of sizeof(struct iface), interface %s", argv[7]);
  402.         return(-1);
  403.     }
  404.     
  405.     /* get the timer control blocks */
  406.     /* must have zeros in structure, so use calloc */
  407.     if ( (timer1 = (struct drv_timer *)calloc(1,sizeof(struct drv_timer))) == (struct drv_timer *)NULLBUF )
  408.     {
  409.         free(intfc_p->hwaddr);
  410.         free(intfc_p->name);
  411.         free(intfc_p);
  412.         tprintf("tsync_attach error: no memory for timer control block structure, size of sizeof(struct drv_timer), interface %s", argv[7]);
  413.         return(-1);
  414.     }
  415.  
  416.  
  417.     dcbp = (DCB *)calloc(1,sizeof(DCB));    /* zero-out the dcb */
  418.     if ( dcbp != (DCB *)NULLBUF )
  419.     {
  420.         dcbp->rxbufsize = rbufsize;
  421. #ifdef OLD_KA9Q
  422.         dcbp->rxbufp = alloc_mbuf(rbufsize+sizeof(struct phdr));
  423. #else
  424.         dcbp->rxbufp = alloc_mbuf(rbufsize);
  425. #endif
  426.         if (dcbp->rxbufp != NULLBUF )    
  427.         {
  428.             dcbp->ioctlparams = (struct tsync_ioctl *)malloc(sizeof(struct tsync_ioctl));
  429.             if ( dcbp->ioctlparams == (struct tsync_ioctl *)NULLBUF )
  430.             {
  431.                 free(timer1);
  432.                 free(intfc_p->hwaddr);
  433.                 free(intfc_p->name);
  434.                 free(intfc_p);
  435.                 free(dcbp->rxbufp);
  436.                 free(dcbp);
  437.                 tprintf("tsync_attach error: no memory for IOCTL params size %x bytes, interface %s", sizeof(struct tsync_ioctl), argv[7]);
  438.                 return(-1);
  439.             }
  440.         }
  441.         else 
  442.         {
  443.             free(timer1);
  444.             free(intfc_p->hwaddr);
  445.             free(intfc_p->name);
  446.             free(intfc_p);
  447.             free(dcbp);
  448.             tprintf("tsync_attach error: no memory for receive buffer, size %x bytes, interface %s", rbufsize, argv[7]);
  449.             return(-1);
  450.         }
  451.     }
  452.     else
  453.     {
  454.         free(timer1);
  455.         free(intfc_p->hwaddr);
  456.         free(intfc_p->name);
  457.         free(intfc_p);
  458.         tprintf("tsync_attach error: no memory for device control block structure, size of sizeof(DCB), interface %s", argv[7]);
  459.         return(-1);
  460.     }
  461.  
  462.  
  463.     if ( Mycall[0] == '\0' )
  464.     {
  465.         free(timer1);
  466.         free(intfc_p->hwaddr);
  467.         free(intfc_p->name);
  468.         free(intfc_p);
  469.         free(dcbp->rxbufp);
  470.         free(dcbp);
  471.         tprintf("tsync_attach error: mycall not set\n");
  472.         return(-1);
  473.     }
  474.  
  475.  
  476.     /* 
  477.      *  Universal Driver Control Block Init -
  478.      *  Except for the saving of old vectors and attached field.
  479.      *  Attached field is saved for the very end.
  480.      */
  481.     udcbp->type = SYNC_8530;            /* 8530 scc */
  482.     
  483.     /* set address of the unit's driver control block */
  484.     udcbp->dcbp = (char *)dcbp;
  485.  
  486.     /* setup this device's interrupt handlers */
  487.     udcbp->prev_vec2 = tsync_txisr;
  488.     udcbp->prev_vec3 = tsync_rxisr;
  489.     udcbp->prev_vec4 = tsync_xstatisr;
  490.  
  491.  
  492.     /*
  493.      * Setup the interface structure and link it to the list
  494.      * of interface structures.
  495.      */
  496.     /* the Ascii name of the driver unit */
  497.     strcpy(intfc_p->name,argv[7]);
  498.  
  499.     /* set the device number, must be able to tell whether */
  500.     /* channel A or channel B is being used */
  501.     dcbp->dev = udcb_dev;
  502.     switch ( udcb_dev ) 
  503.     {
  504.         case TWINCOMM1:
  505.             dcbp->zhwmap.ctl = (int16)(Twin_io_base+SCCA_CMD);
  506.             dcbp->zhwmap.data = (int16)(Twin_io_base+SCCA_DATA);
  507.             break;
  508.  
  509.         case TWINCOMM2: 
  510.             dcbp->zhwmap.ctl = (int16)(Twin_io_base+SCCB_CMD);
  511.             dcbp->zhwmap.data = (int16)(Twin_io_base+SCCB_DATA);
  512.             break;
  513.  
  514.     }
  515.  
  516.  
  517. /* not for NOS    intfc_p->recv = tsync_recv;   
  518. */
  519.     intfc_p->mtu = xbufsize - MAX_AX25_HDR_LEN;
  520.     intfc_p->ioctl =  tsync_ioctl;
  521.     intfc_p->raw = tsync_raw;
  522.     intfc_p->addr = ipaddr;            /* new for NOS */
  523.     intfc_p->stop = tsync_stop;
  524.     intfc_p->dev = udcb_dev;
  525.  
  526.     setencap(intfc_p,"AX25");
  527.  
  528.     /* For packet radio put in the sender's "call letters" */
  529.     memcpy(intfc_p->hwaddr,Mycall,AXALEN);  
  530.  
  531.     /* lastly, but very importantly, put in the LL of interfaces */
  532.     intfc_p->next = Ifaces;
  533.     Ifaces = intfc_p;
  534.  
  535.  
  536.     /* 
  537.      * Initialize the unit's driver control block 
  538.      */
  539.     dcbp->iface = intfc_p;        /* new for NOS - save the iface */
  540.                     /* address for use in queueing */
  541.                     /* mbufs onto Hopper */
  542.     dcbp->txstate = IDLE;
  543.     dcbp->xmtq = (struct drvbuf *)NULLBUF;
  544.     dcbp->xmtqtail = (struct drvbuf *)NULLBUF;     /* milt */
  545.     dcbp->freem = (struct drvbuf *)NULLBUF;          /* milt */
  546.  
  547.     dcbp->rxstate = IDLE;    
  548.     dcbp->rxbufsize = atoi(argv[8]);
  549.  
  550. /*milt 3/15/91
  551.     dcbp->rxqhat.headp = NULLBUF;
  552.     dcbp->rxqhat.tailp = NULLBUF;
  553. */
  554.  
  555.     /* Configure DMA stuff */
  556.     dcbp->dma_flg = dmaflg;
  557.     if(dmaflg == TRUE)
  558.     {
  559.  
  560.         dcbp->dma_rx_chan = rxdmachan;
  561.         dcbp->dma_tx_chan = txdmachan;
  562.  
  563.         switch(dcbp->dma_tx_chan)
  564.         {
  565.             case 1:    dcbp->dma_tx_pagereg = 0x83;
  566.                 dcbp->dma_tx_cnt_reg = DMA1CNT;
  567.                 dcbp->dma_tx_addr_reg = DMA1ADR;
  568.                 break;
  569.             case 3: dcbp->dma_tx_pagereg = 0x82;
  570.                 dcbp->dma_tx_cnt_reg = DMA3CNT;
  571.                 dcbp->dma_tx_addr_reg = DMA3ADR;
  572.                 break;
  573.         }
  574.  
  575.         switch(dcbp->dma_rx_chan)
  576.         {
  577.             case 1:    dcbp->dma_rx_pagereg = 0x83;
  578.                 dcbp->dma_rx_cnt_reg = DMA1CNT;
  579.                 dcbp->dma_rx_addr_reg = DMA1ADR;
  580.                 break;
  581.             case 3: dcbp->dma_rx_pagereg = 0x82;
  582.                 dcbp->dma_rx_cnt_reg = DMA3CNT;
  583.                 dcbp->dma_rx_addr_reg = DMA3ADR;
  584.                 break;
  585.         }
  586.  
  587.         /* SET up of the mode reg values for the DMA channels to be used */
  588.         if(hdxflg == FALSE) 
  589.         {
  590.             /* FULL DUPLEX the values never change between rx/tx */
  591.             if(rxdmachan == 3)
  592.                 dcbp->dma_rx_mode = dcbp->dma_tx_mode = PKTWIN_DMA_FDX_T1R3;
  593.             else
  594.                 dcbp->dma_rx_mode = dcbp->dma_tx_mode = PKTWIN_DMA_FDX_T3R1;
  595.         }
  596.         else
  597.         {
  598.             /* Half DUPLEX... */
  599.             if(rxdmachan == 3)
  600.             {
  601.                 dcbp->dma_rx_mode = PKTWIN_DMA_HDX_R3;
  602.                 dcbp->dma_tx_mode = PKTWIN_DMA_HDX_T3;
  603.             }
  604.             else
  605.             {
  606.                 dcbp->dma_rx_mode = PKTWIN_DMA_HDX_R1;
  607.                 dcbp->dma_tx_mode = PKTWIN_DMA_HDX_T1;
  608.             }
  609.         }
  610.  
  611.     }        /* End of dma info setup */
  612.  
  613.  
  614.     /* no need to init stats because calloc zero-ed the dcbp */
  615.  
  616.     /* default IOCTL Params */
  617.     dcbp->ioctlparams->xmitdelay = 250;    /* 250 Ms */
  618.     dcbp->ioctlparams->persist= 64;        /* 25% of 255 = 64 persistance*/
  619.     dcbp->ioctlparams->slotime = 10;    /* 10 Ms */
  620.     dcbp->ioctlparams->squelch   = 200;    /* 200 Ms */
  621.  
  622.     /* set the rxavailbufs parameter */
  623.     dcbp->ioctlparams->rxavailbufs = 0;    /* zero 1st */
  624.     if ( argc >= 16 )
  625.         dcbp->ioctlparams->rxavailbufs = atoi(argv[15]);
  626.     
  627.     if ( dcbp->ioctlparams->rxavailbufs < 4 )
  628.         dcbp->ioctlparams->rxavailbufs = 4;    /* 4 is min!! */
  629.  
  630.     /* 
  631.      * setup the packet header for the DRIVER 
  632.      * calling this routine 
  633.      */
  634.     /* init to packet header's byte count */
  635. #ifdef OLD_KA9Q
  636.     dcbp->rxbufp->cnt = sizeof(struct phdr);
  637.     hdr = (struct phdr *)dcbp->rxbufp->data;
  638.     hdr->type = intfc_p->type;
  639.     hdr->iface = intfc_p;
  640.     /* Rx data goes in after packet header  */
  641.     /* works because data is a char pointer */
  642.     dcbp->rxbufp->data += sizeof(struct phdr);
  643. #else
  644.     dcbp->rxbufp->cnt = 0;
  645. #endif
  646.  
  647.     dcbp->rxcurp = dcbp->rxbufp->data;
  648.  
  649.     /* get as many of the requested rx pre-allocated mbuf's */
  650.     dcbp->rxavailq = NULLBUF;
  651.  
  652.     f_getavail(&(dcbp->rxavailq), dcbp->ioctlparams->rxavailbufs,
  653.                     dcbp->rxbufsize, 
  654.                 &(dcbp->rxavailcount), 
  655.                    intfc_p, dcbp->dma_flg);
  656.  
  657. #ifdef TSYNC_DEBUG_PRT
  658. printf("TSYNC_ATTACH: rxavailbufs is %d, rxavailcount is %d\n", dcbp->ioctlparams->rxavailbufs, dcbp->rxavailcount); 
  659. #endif
  660.  
  661.     /* put in the timer control blocks */
  662.     dcbp->timer1 = timer1;
  663.  
  664.     dcbp->baud = (int16)atoi(argv[10]);
  665.     /* set up duplex mode... */
  666.     dcbp->hduplex = hdxflg;
  667.  
  668.  
  669.     /* SET UP CLOCKING OPTIONS... */
  670.     /* Default to Externally supplied clocks */
  671.  
  672.     /* select Tx clock mode for SCC */
  673.     /* Default is to expect clock to be supplied externally */
  674.     if((argc >= 12) && (strcmpi(argv[11],"int") == 0))dcbp->txclk_extrn = FALSE;
  675.     else dcbp->txclk_extrn = TRUE;
  676.  
  677.     /* select Rx clock mode for SCC */
  678.     /* Default is to expect clock to be supplied externally */
  679.     if((argc >= 13) && (strcmpi(argv[12],"int") == 0))dcbp->rxclk_extrn = FALSE;
  680.     else dcbp->rxclk_extrn = TRUE;
  681.  
  682.     /* select data coding scheme for SCC */
  683.     /* Default is NRZ */
  684.     if(argc >= 14)
  685.     {
  686.         if((strlen(argv[13]) >= strlen("nrzi")) && 
  687.                         (strcmpi(argv[13],"nrzi") == 0))
  688.         {
  689.             dcbp->nrzi_flg = TRUE;
  690.         }
  691.         else dcbp->nrzi_flg = FALSE;
  692.     }
  693.  
  694.     /*
  695.      *  Now for the hardware dependent initializations.
  696.        *  If device control block is an 8530 driver, then SCC
  697.      *  stuff needs to be done.  
  698.      *
  699.      *  udcbp->type tells if its an 8530
  700.      *  intfc_p->dev tells which unit/dev
  701.       *
  702.      */
  703.  
  704. #ifdef TSYNC_DEBUG_PRT
  705.     printf("tsync_attach: intfc_p->dev = %x config 8530 HW \n", intfc_p->dev);
  706. #endif
  707.  
  708.  
  709.     i_state = dirps();    /* {dgl} protect the writescc's */
  710.                 /* and the vector reads/writes */
  711.     /* disable our ints */
  712.     maskoff(Twin_vector);
  713.     outportb(Twin_io_base+INT_CFG,(Twin_sercfg &= (~PKTWIN_EI)));
  714.  
  715.  
  716.     /*
  717.      * Can only reset the chip when it is not being used!!!
  718.      * This handles first time use of 8530.
  719.      * Set the base vector - since it is common set it here.
  720.      */
  721.  
  722.  
  723.     if ( (Twin_udcb[TWINCOMM1].attached == FALSE) && 
  724.          (Twin_udcb[TWINCOMM2].attached == FALSE) )
  725.     {
  726.  
  727.         /* This should NOT be done... if either ports are in use */
  728.         /* for ANYTHING */
  729.         Twin_write_scc(dcbp->zhwmap.ctl,R9,(dcbp->wr9 = FHWRES));     
  730.  
  731.  
  732.         /* Save original interrupt vector */
  733.         Twin_oldvec = (INTERRUPT (*)())getirq(Twin_vector);
  734.         
  735.         udcbp->prev_vec1 = (void (*)())Twin_oldvec; 
  736.  
  737.         /* New vector... */
  738.         setirq(Twin_vector, Twin_handler);
  739.  
  740.         /* set up register images, and regs to defaults */
  741.  
  742.         Twin_sercfg = Twin_dmacfg = 0;
  743.         outportb(Twin_io_base+INT_CFG,Twin_sercfg);
  744.         outportb(Twin_io_base+DMA_CFG,Twin_dmacfg);
  745.     }
  746.     /*
  747.      * Reset the individual channel.  Handles cases of re-attaching
  748.      * channels and first attachment.
  749.      *
  750.      * For safetys sake set the Disable Lower Chain bit too.
  751.      */
  752.     if ( dcbp->dev == TWINCOMM1 )
  753.         Twin_write_scc(dcbp->zhwmap.ctl,R9,(dcbp->wr9 = 0x84));    
  754.     else    
  755.         Twin_write_scc(dcbp->zhwmap.ctl,R9,(dcbp->wr9 = 0x44));    
  756.     
  757.     /* wait a bit... for chip to settle after reset */
  758.     /* Just in case... */
  759.     for(i=0;i<20;i++);     /* milt */ 
  760.  
  761.     /* configure the 8530 SCC */     
  762.     if(tsync_hwinit(dcbp) == -1)
  763.     {
  764.         /* An error occurred in the hw init */
  765.         /* so clean up and leave... */
  766.  
  767.         /* Mark it attached so the following detach routine */
  768.         /* won't complain */
  769.         udcbp->attached = TRUE;
  770.         if_detach(intfc_p);
  771.  
  772.         /* re-enable this interrupt input */
  773.         maskon(Twin_vector);
  774.  
  775.         restore(i_state);
  776.         tprintf("PackeTwin hardware unavailable or malfunctioning...\n");
  777.         return(-1);
  778.     }
  779.  
  780.  
  781.     /* enable PackeTwin ints */
  782.     outportb(Twin_io_base+INT_CFG,(Twin_sercfg |= PKTWIN_EI));
  783.  
  784.     /* enable this level ints on 8259 */
  785.     maskon(Twin_vector);
  786.  
  787.     /* {dgl} enable system-wide ints */
  788.     restore(i_state);
  789.  
  790.     /*
  791.      *  This channel is ATTACHED.
  792.      */
  793.     udcbp->attached = TRUE;
  794.  
  795.  
  796.     /* new for NOS - start the two processes needed by the */
  797.     /* sync driver; one is for getting pre-allocated buffers */
  798.     /* the other is for kicking the transmitter after its */
  799.     /* timer has expired or when it needs a transmitted */
  800.     /* message free-ed.  P.S. must do after attached set to TRUE */
  801.  
  802.     sprintf(tmpbuf,"%s:getbuf",intfc_p->name);
  803.     dcbp->rxavproc = newproc(tmpbuf,150,tsync_rxavget,udcb_dev,NULL,NULL,0);
  804.  
  805. #ifdef TSYNC_DEBUG_PRT
  806.     printf("tsync_attach: called newproc for tsync_getbfs, procid = %lx \n",
  807.         dcbp->rxavproc);
  808. #endif
  809.  
  810.  
  811.     sprintf(tmpbuf,"%s:kick",intfc_p->name);
  812.     dcbp->txkickproc = newproc(tmpbuf,150,tsync_txkick,udcb_dev,NULL,NULL,0);
  813.  
  814. #ifdef TSYNC_DEBUG_PRT
  815.     printf("tsync_attach: called newproc for tsync_txkick, procid = %lx \n",
  816.         dcbp->txkickproc);
  817.  
  818.     tprintf("tsync_attach: All done!!! \n");
  819. #endif
  820.     sprintf(tmpbuf,"%s:free",intfc_p->name);
  821.     dcbp->freetxproc = newproc(tmpbuf,150,tsync_freetx,udcb_dev,NULL,NULL,0);
  822.  
  823.     /* Let our new processes get running... */
  824.     for(i=0;i<10;i++)pwait(NULL);
  825.  
  826.     return(0);
  827.  }
  828. /*
  829.  * End of tsync_attach()
  830.  ******************************************************************/
  831.  
  832.  
  833.  
  834. /* 
  835.  *  Stop I/O
  836.  */
  837. int
  838. tsync_stop(intfcp)
  839. struct iface *intfcp;
  840. {
  841.     DCB *sp;
  842.     UNI_DCB *udcbp;
  843.     int16 dev;
  844.     char     i_state;
  845.     struct drvbuf *xbufp, *tmpptr;
  846.     struct mbuf *tmpbufp;
  847.  
  848.  
  849.     dev = intfcp->dev;
  850.     udcbp = &Twin_udcb[dev];        /* dev num is index number!!! */
  851.  
  852.     if ( udcbp->attached != TRUE )
  853.     {
  854.         tprintf("tsync_stop err: Device already stopped/de-attached!!\n");
  855.         return(0);
  856.     }
  857.     else if ( (dev != TWINCOMM1) && (dev != TWINCOMM2) )
  858.          return(0);        /* not for this driver */
  859.  
  860.     sp = (DCB *)Twin_udcb[dev].dcbp;
  861.  
  862.     /* kill off the support processes */
  863.     /* so they don't allocate memory */
  864.     /* whils't we're freeing it */
  865.  
  866.     killproc(sp->rxavproc);
  867.     killproc(sp->txkickproc);
  868.     killproc(sp->freetxproc);
  869.  
  870.     /* Turn off interrupts */
  871.  
  872.     i_state = dirps();
  873.  
  874.     /* mark port as available - do it now for if below */
  875.     udcbp->attached = FALSE;
  876.  
  877.  
  878.  
  879.     /* Disable the DMA channels if any... */
  880.     if(sp->dma_flg)
  881.     {
  882.         outportb(DMAWSMR,sp->dma_rx_chan | 0x04);
  883.         outportb(DMAWSMR,sp->dma_tx_chan | 0x04);
  884.     }
  885.  
  886.     /*
  887.      * Can only reset the chip when it is not being used!!!
  888.      * This handles first time use of 8530.
  889.      * Set the base vector - since it is common set it here.
  890.      */
  891.  
  892.  
  893.     if ( (Twin_udcb[TWINCOMM2].attached == FALSE) && 
  894.          (Twin_udcb[TWINCOMM1].attached == FALSE) )
  895.     {
  896.  
  897.         /* This should NOT be done... if either ports are in use */
  898.         /* for ANYTHING */
  899.         Twin_write_scc(sp->zhwmap.ctl,R9,(sp->wr9 = FHWRES));     
  900.  
  901.         /* Restore original interrupt vector */
  902.         setirq(Twin_vector,(INTERRUPT (*)())udcbp->prev_vec1);
  903.  
  904.         /* Disable our board from generating ints... */
  905.         outportb(Twin_io_base+INT_CFG,(Twin_sercfg &= (~PKTWIN_EI)));
  906.     }
  907.  
  908.     /*
  909.      * Reset the individual channel.  Handles cases of re-attaching
  910.      * channels and first attachment.
  911.      *
  912.      */
  913.  
  914.     if ( sp->dev == TWINCOMM1 )
  915.     {
  916.         Twin_write_scc(sp->zhwmap.ctl,R9,(sp->wr9 = 0x88));    
  917.  
  918.         /* Drop DTR to indicate we are gone...*/
  919.         outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_DTRA_ON)));
  920.     }
  921.     else    
  922.     {
  923.         Twin_write_scc(sp->zhwmap.ctl,R9,(sp->wr9 = 0x48));    
  924.         /* Drop DTR to indicate we are gone...*/
  925.         outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_DTRB_ON)));
  926.     }
  927.  
  928.     restore(i_state);
  929.  
  930.     /* 
  931.      * Flush all buffers and queue's
  932.        */
  933.  
  934.     /* Now free all preallocated rx buffers on the rx available queue */    
  935.     while((tmpbufp = f_dequeavail(&sp->rxavailq,&sp->rxavailcount)) != NULLBUF)
  936.         free(tmpbufp);        /* these mbuf's are one contigous */
  937.                     /* chunk of memory */
  938.  
  939.  
  940.     if ( sp->rxbufp != NULLBUF )
  941.          free(sp->rxbufp);
  942.  
  943.     /* free up any pending transmit buffers... */
  944.     while(sp->xmtq != (struct drvbuf *)NULLBUF)
  945.     {
  946.         tmpptr = sp->xmtq->next;
  947.         free(sp->xmtq);
  948.         sp->xmtq = tmpptr;
  949.     }
  950.  
  951.     /* Free any previously sent frames, which are in the waiting to be */
  952.     /* free'd queue */
  953.  
  954.     /* disable ints here to get queue head... */
  955.     i_state = dirps();            /* seems unecessary milt */
  956.     xbufp = sp->freem;
  957.     sp->freem = (struct drvbuf *)NULLBUF;
  958.     restore(i_state);
  959.  
  960.     /* Here xbufp is a "to be free'd"  */
  961.     /* queue pointer" */
  962.     /* now free memory of all the xmitted messages */
  963.     while ( xbufp != (struct drvbuf *)NULLBUF )
  964.     {
  965.         tmpptr = xbufp->next;
  966.         free((char *)xbufp);
  967.         xbufp = tmpptr;
  968.     }
  969.  
  970.  
  971.  
  972.     /*
  973.      * Deallocate other driver related memory structures 
  974.      */
  975.     free(sp->timer1);
  976.     free(sp->ioctlparams);
  977.     free(sp);
  978.  
  979.     return(0);
  980. }
  981.  
  982.  
  983. /* 
  984.  * Display a PackeTwin SYNCHRONOUS channel's statistics.
  985.  */
  986. int
  987. do_tsync_stat()    
  988. {
  989.     DCB *dcbp;
  990.     UNI_DCB *udcbp;
  991.     int16 dev;
  992.     unsigned long rxerrcnt;
  993.     bool hd8530;
  994.  
  995.     /* Header for all the Synchronous channel's on the card */
  996.     tprintf("                    PackeTwin Synchronous Driver Release %s\n\n"
  997.                                                             ,Twin_dvr_version);
  998.  
  999.     hd8530 = FALSE;
  1000.     for (dev=0, udcbp = &Twin_udcb[0]; dev < 2 ; udcbp++, dev++) 
  1001.     {
  1002.         if ( udcbp->type == SYNC_8530 )
  1003.         {
  1004.             if ( udcbp->attached == TRUE )
  1005.             {
  1006.                 if ( !hd8530 )
  1007.                 {
  1008.             tprintf("\n");
  1009.             tprintf("8530   RxChars   RxPacks  Rxerrs  RxBf   Txchars   TxPacks TxUns  RxNoBf\n");
  1010.             tprintf("----- ---------  -------  ------  ----  ---------  ------- -----  ------\n");
  1011.                     hd8530 = TRUE;
  1012.                 }
  1013.  
  1014.                 dcbp = (DCB *)udcbp->dcbp;
  1015.                 /* total receiver error count */
  1016.                 rxerrcnt = dcbp->rxcrcerrcnt + dcbp->rxovercnt;
  1017.  
  1018.             tprintf(" %4.1d %#9lu  %#7lu  %#6lu  %#4lu  %#9lu  %#7lu %#5lu  %#6lu\n",
  1019.                        dev, dcbp->rxbytecnt,
  1020.                        dcbp->rxpackcnt,
  1021.                        rxerrcnt, 
  1022.                        dcbp->rxavailcount,
  1023.                     dcbp->txbytecnt,
  1024.                     dcbp->txpackcnt,
  1025.                        dcbp->txunderun,
  1026.                     dcbp->nobufs);
  1027.  
  1028. #ifdef TSYNC_DEBUG_PRT
  1029. printf("Crc's: %lx Overruns: %lx\n",dcbp->rxcrcerrcnt,dcbp->rxovercnt);
  1030. printf("DCB ptr: %p\n",dcbp);
  1031. printf("rxcurp: %p  rxbufp: %p  rxbufp->cnt: %d\n",dcbp->rxcurp,
  1032.                                                       dcbp->rxbufp,
  1033.                                                       dcbp->rxbufp->cnt);
  1034.  
  1035. #endif
  1036.             }
  1037.         }
  1038.         
  1039.     }  /* end of for loop */
  1040.  
  1041.     for (dev=0, udcbp = &Twin_udcb[0]; dev < 2; udcbp++, dev++) 
  1042.     {
  1043.         if ( udcbp->attached == FALSE )
  1044.             tprintf("\nChannel %d is UN-attached", dev);
  1045.     }
  1046.  
  1047.     tprintf("\n");
  1048.     return(0);
  1049. }
  1050.  
  1051. /* Subroutine to set kiss params in channel tables */
  1052. int32
  1053. tsync_ioctl(iface,cmd,set,val)
  1054. struct iface *iface;
  1055. int cmd;
  1056. int set;
  1057. int32 val;
  1058. {
  1059.     DCB *dcbp;
  1060.  
  1061.     dcbp = (DCB *)Twin_udcb[iface->dev].dcbp;
  1062.  
  1063.     switch(cmd){
  1064.     case PARAM_TXDELAY:
  1065.         if(set)
  1066.             dcbp->ioctlparams->xmitdelay = (int16)val;
  1067.         return dcbp->ioctlparams->xmitdelay;
  1068.  
  1069.     case PARAM_PERSIST:
  1070.         if(set)
  1071.             dcbp->ioctlparams->persist = (uchar)val;
  1072.         return uchar(dcbp->ioctlparams->persist);
  1073.     case PARAM_SLOTTIME:
  1074.         if(set)
  1075.             dcbp->ioctlparams->slotime = (int16)val;
  1076.         return dcbp->ioctlparams->slotime;
  1077.     case PARAM_TXTAIL:
  1078.         if(set)
  1079.             dcbp->ioctlparams->squelch = (int16)val;
  1080.         return dcbp->ioctlparams->squelch;
  1081.  
  1082.     case PARAM_RXBUFS:
  1083.         if(set)
  1084.             dcbp->ioctlparams->rxavailbufs = (int16)val;
  1085.         return dcbp->ioctlparams->rxavailbufs;
  1086.  
  1087.     }
  1088.     return -1;
  1089. }
  1090.  
  1091. /* 
  1092.  * Initialize the SZ driver's hardware for SDLC, i.e. the 85c30 SCC.
  1093.  */ 
  1094. int
  1095. tsync_hwinit(dcbp)
  1096. register DCB *dcbp;
  1097. {
  1098.     char i_state;        /* for PackeTwin this is 2 bytes */
  1099.     int16 tc;        /* time constant for 8530 */
  1100.     int    i;
  1101.     bool    baudclk_flg;
  1102.     bool    both_clocks_internal;
  1103.     void tsync_loopback();
  1104.     void enable_escc();
  1105.     int    nop1 = 0;
  1106.  
  1107. #define nop nop1++;
  1108.  
  1109.  
  1110. #ifdef TSYNC_DEBUG_PRT
  1111.     printf("Initializing TSYNC_DRIVER device num = %d\n", dcbp->dev);
  1112. #endif
  1113.     i_state = dirps();
  1114.  
  1115.  
  1116.     /* if both clocks are specified as internal, then override the */
  1117.     /* specified data coding scheme, and MAKE it NRZI */
  1118.     if((dcbp->rxclk_extrn == FALSE) && (dcbp->txclk_extrn == FALSE))
  1119.     {
  1120.         dcbp->nrzi_flg = TRUE;
  1121.         both_clocks_internal = TRUE;
  1122.     }
  1123.     else 
  1124.         both_clocks_internal = FALSE;
  1125.  
  1126.     /* If we are not using DMA, then try to enable the extended TX FIFO */
  1127.     if(!(dcbp->dma_flg)) enable_escc(dcbp);
  1128.  
  1129.     /* times 1 x clock, SDLC mode */
  1130.     /* always set R4 before R1, R3, R6, and R7 */
  1131.     Twin_write_scc(dcbp->zhwmap.ctl,R4,(dcbp->wr4 = 0x20));           
  1132.  
  1133.     /* mask-off all interrupt types */
  1134.     /* No DMA, No Ints... */
  1135.     Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0));
  1136.  
  1137.     /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  1138.     Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xd8));            
  1139.  
  1140.     /* DTR, Tx 8 bit/chars and Tx disabled */
  1141.     Twin_write_scc(dcbp->zhwmap.ctl,R5,(dcbp->wr5 = 0x60));
  1142.  
  1143.     /* no SDLC transmit secondary address */
  1144.     Twin_write_scc(dcbp->zhwmap.ctl,R6,(dcbp->wr6 = 0));
  1145.  
  1146.     /* Set SDLC flag */
  1147.     Twin_write_scc(dcbp->zhwmap.ctl,R7,(dcbp->wr7 = FLAG));
  1148.  
  1149.     if(dcbp->nrzi_flg != TRUE)
  1150.     {
  1151.         /* Preset Tx CRC, NRZ Mode, flags on idle and */
  1152.         /* underrun 8 bit sync mode */
  1153.         Twin_write_scc(dcbp->zhwmap.ctl,R10,(dcbp->wr10 = 0x84));
  1154.     }
  1155.  
  1156.     else
  1157.     {
  1158.         /* Preset Tx CRC, NRZI Mode, flags on idle and */
  1159.         /* aborts on underrun 8 bit sync mode */
  1160.         Twin_write_scc(dcbp->zhwmap.ctl,R10,(dcbp->wr10 = 0xa4));
  1161.     }
  1162.  
  1163.     /* Set up BRG and DPLL multiplexers */
  1164.  
  1165.     /* Case where only the Rx clock is supplied externally */
  1166.     if((dcbp->rxclk_extrn == TRUE) && (dcbp->txclk_extrn != TRUE))
  1167.     {
  1168.         /* Tx Clk from BRG. Rcv Clk external on RTxC, */
  1169.         /* TRxC pin outputs BRgen */
  1170.         Twin_write_scc(dcbp->zhwmap.ctl,R11,(dcbp->wr11 = 0x16));
  1171.         tc = ( (XTAL) / (dcbp->baud *2))-2;
  1172.         baudclk_flg = TRUE;
  1173.  
  1174.         /* disable the external TX clock receiver input */
  1175.         if(dcbp->dev == TWINCOMM1) outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_EXTCLKA)));    
  1176.         else outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_EXTCLKB)));
  1177.     }
  1178.  
  1179.     /* Case where only the Tx clock is supplied externally */
  1180.     if((dcbp->txclk_extrn == TRUE) && (dcbp->rxclk_extrn != TRUE))
  1181.     {
  1182.         /* Tx Clk external on TRxC,  Rcv Clk internal BRgen, */
  1183.         /* TRxC pin is input TX clock */
  1184.         Twin_write_scc(dcbp->zhwmap.ctl,R11,(dcbp->wr11 = 0x4a));
  1185.         tc = ( (XTAL) /(dcbp->baud *2))-2;
  1186.         baudclk_flg = TRUE;
  1187.  
  1188.         /* enable the external TX clock receiver input */
  1189.         if(dcbp->dev == TWINCOMM1) outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_EXTCLKA));    
  1190.         else outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_EXTCLKB));    
  1191.     }
  1192.  
  1193.     /* Case where both clocks are supplied externally */
  1194.     if((dcbp->txclk_extrn == TRUE) && (dcbp->rxclk_extrn == TRUE))
  1195.     {
  1196.         /* Tx Clk external on TRxC,  Rcv Clk external on RTxC, */
  1197.         /* TRxC pin is input TX clock */
  1198.         Twin_write_scc(dcbp->zhwmap.ctl,R11,(dcbp->wr11 = 0x0a));
  1199.         baudclk_flg = FALSE;
  1200.  
  1201.         /* enable the external TX clock receiver input */
  1202.         if(dcbp->dev == TWINCOMM1) outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_EXTCLKA));    
  1203.         else outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_EXTCLKB));    
  1204.  
  1205.         /*DTR is in REQ mode for possible DMA */
  1206.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x04));
  1207.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x00));         
  1208.     }
  1209.  
  1210.     if(both_clocks_internal == TRUE)
  1211.     {
  1212.         /* Tx Clk from BRG. Rcv Clk from DPLL, TRxC pin outputs DPLL */
  1213.         Twin_write_scc(dcbp->zhwmap.ctl,R11,(dcbp->wr11 = 0x77));
  1214.  
  1215.         /* time constant 32X BRG divisor */
  1216.         tc = ((XTAL/32)/(dcbp->baud * 2))-2;    
  1217.         /* DGL... fix a cut and paste error... */
  1218.         /* baudclk_flg = FALSE; */
  1219.         baudclk_flg = TRUE; 
  1220.  
  1221.         /* disable the external TX clock receiver input */
  1222.         if(dcbp->dev == TWINCOMM1) outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_EXTCLKA)));    
  1223.         else outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_EXTCLKB)));    
  1224.  
  1225.     }
  1226.  
  1227.     if(baudclk_flg == TRUE)
  1228.     {
  1229.  
  1230.         /* lower byte */
  1231.         Twin_write_scc(dcbp->zhwmap.ctl,R12,(dcbp->wr12 = (tc&0xFF)));      
  1232.  
  1233.         /* upper byte */
  1234.         Twin_write_scc(dcbp->zhwmap.ctl,R13,(dcbp->wr13 = ((tc>>8)&0xFF))); 
  1235.  
  1236.         /* enable the BR generator... */
  1237.         /*DTR is in REQ mode for possible DMA */
  1238.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x07));
  1239.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x03));         
  1240.     }
  1241.  
  1242.  
  1243.     if(both_clocks_internal == TRUE)
  1244.     {
  1245.  
  1246.         /* BRG off, Enter Search mode */
  1247.         /*DTR is in REQ mode if possible DMA */
  1248.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x26));
  1249.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x22));
  1250.  
  1251.         /* Set DPLL source to BRGEN */
  1252.         /*DTR is in REQ mode for possible DMA */
  1253.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x86));
  1254.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x82));
  1255.  
  1256.         /* Set DPLL mode to NRZI */
  1257.         /*DTR is in REQ mode for possible DMA */
  1258.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0xe6));
  1259.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0xe2));
  1260.  
  1261.  
  1262.  
  1263. /* At this point; the DPLL is searching for a data edge to begin clocking */
  1264. /*           The baud rate gen is set to 32 times the desired rate.. */
  1265. /*          The transmitter is based on the BRGEN. (i.e. 32x )      */
  1266. /*                                                                        */
  1267. /* Procedure here; Set up an external loopback, then send aborts, to      */
  1268. /*            trigger and sync up the DPLL.                */
  1269. /*            After the DPLL is running, then reprogram the Xmitter  */
  1270. /*            to use the DPLL output as it's transmitter clock.      */
  1271. /*            This saves us having to reprogram the BRG whenever we  */
  1272. /*           switch from RECV to TX and back.                       */
  1273. /*          
  1274.  
  1275.         /* Turn on the recvr */    
  1276.         /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  1277.         Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xd9));
  1278.  
  1279.         /* Turn on the transmitter */
  1280.         /* DTR, Tx 8 bit/chars and Tx enabled */
  1281.         Twin_write_scc(dcbp->zhwmap.ctl,R5,(dcbp->wr5 = 0x68));         
  1282.  
  1283.         /* reset TX CRC */
  1284.         Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x80));         
  1285.  
  1286.         /* enable the BR generator to start things up...*/
  1287.         /*DTR is in REQ mode for possible DMA */
  1288.         if(dcbp->dma_flg)Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x07));
  1289.         else Twin_write_scc(dcbp->zhwmap.ctl,R14,(dcbp->wr14 = 0x03));
  1290.  
  1291.  
  1292.         /* OK now turn on the loopback */
  1293.         tsync_loopback(dcbp,ON);
  1294.  
  1295.         /* Now send sum aborts... */
  1296.  
  1297.         for(i=0;i<25;i++)
  1298.         {
  1299.  
  1300.             /* read and toss any  data */
  1301.             inportb(dcbp->zhwmap.data);
  1302.             inportb(dcbp->zhwmap.data);
  1303.             inportb(dcbp->zhwmap.data);
  1304.             inportb(dcbp->zhwmap.data);
  1305.  
  1306.             Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x18));         /* send abort */
  1307.         }
  1308.  
  1309.         /* OK, now the DPLL should be running at ~32 * baudrate requested */
  1310.         /* Turn off the loopback... */
  1311.  
  1312.         tsync_loopback(dcbp,OFF);
  1313.  
  1314.  
  1315.         /* Now reprogram the transmitter clock to use the DPLL output */
  1316.  
  1317.         /* TX clk is DPLL, RX clk is DPLL, TRxc is DPLL OUT */
  1318.         Twin_write_scc(dcbp->zhwmap.ctl,R11,(dcbp->wr11 = 0x7f));
  1319.  
  1320.         /* dgl for G3RUH modems... I need to do AUTO-ENABLES... */
  1321.         Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  1322.  
  1323.  
  1324.     }
  1325.  
  1326.     else
  1327.     {
  1328.  
  1329.         /* Turn on the recvr */    
  1330.         /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  1331.  
  1332.         /*  no autoenables */
  1333.         /*
  1334.         Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xd9));         
  1335.         */
  1336.  
  1337.         /* dgl for G3RUH modems... I need to do AUTO-ENABLES... */
  1338.         Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  1339.  
  1340.     }    
  1341.  
  1342.     /* Turn off external interrupts (like CTS/CD) */
  1343.     Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 = 0x00));
  1344.  
  1345.     
  1346.     /* TRANSMITTER OFF */
  1347.     Twin_write_scc(dcbp->zhwmap.ctl,R5,(dcbp->wr5 = 0x60)); /* TX off now */
  1348.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x80)); /* reset TX CRC generator */
  1349.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x40)); /* reset RX CRC checker */
  1350.  
  1351.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x28)); /* reset TX int pending */
  1352.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x28)); /* reset TX int pending */
  1353.     
  1354.  
  1355.     /* reset extrn/sts ints... twice */
  1356.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x10));
  1357.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x10));
  1358.  
  1359.     /* if we are interrupt driven only: then allow ints for ALL RCV cndxs,
  1360.     */
  1361.     if(dcbp->dma_flg == FALSE)
  1362.         Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0x11));
  1363.  
  1364.     /* otherwise interrupt on special rcv cdx only */
  1365.     /* DMA req mode Req on rcv, Req enabled */
  1366.     else  Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0xf9));
  1367.  
  1368.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x30)); /* reset error bits */
  1369.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x30)); /* twice superstition */
  1370.  
  1371.     /* If neither of the PKTwin's ports are currently attached*/
  1372.     /* Then set up the prescaler timer */
  1373.     if ( (Twin_udcb[TWINCOMM2].attached == FALSE) && 
  1374.          (Twin_udcb[TWINCOMM1].attached == FALSE) )
  1375.     {
  1376.         inportb(Twin_io_base+CLR_TMR1);
  1377.         nop;
  1378.         inportb(Twin_io_base+CLR_TMR2);
  1379.         nop;
  1380.  
  1381.         /* Timer counter channel 0 */
  1382.         /* 1 ms period */
  1383.         outportb(Twin_io_base+TMR_CTRL,(unsigned char)0x36);
  1384.         nop;
  1385.         outportb(Twin_io_base+TMR_CNT0,(unsigned char)0x00);
  1386.         nop;
  1387.         outportb(Twin_io_base+TMR_CNT0,(unsigned char)0x18);
  1388.         nop;
  1389.  
  1390.         outportb(Twin_io_base+TMR_CTRL,(unsigned char)0x70);
  1391.         nop;
  1392.         inportb(Twin_io_base+CLR_TMR1);
  1393.         nop;
  1394.  
  1395.         outportb(Twin_io_base+TMR_CTRL,(unsigned char)0xB0);
  1396.         nop;
  1397.         inportb(Twin_io_base+CLR_TMR2);
  1398.         nop;
  1399.     }
  1400.  
  1401.     if(dcbp->dev == TWINCOMM1)
  1402.     {
  1403.         /* mode setup for this channel's driver timer */
  1404.         /* Set it's timer for 1 tick and let it expire */
  1405.         outportb(Twin_io_base+TMR_CTRL,(unsigned char)0x70);
  1406.         nop;
  1407.         inportb(Twin_io_base+CLR_TMR1);
  1408.         nop;
  1409.  
  1410.  
  1411.         /* If the timer hasn't gone off, the hardware is either */
  1412.         /* not present, or broken... */
  1413.         if(!inportb(Twin_io_base+INT_REG) & 0x02)
  1414.         {
  1415.             restore(i_state);
  1416.             return(-1);
  1417.         }
  1418.  
  1419.         /* Assert DTR to indicate we are alive...*/
  1420.         outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_DTRA_ON));
  1421.         
  1422.     }
  1423.     if(dcbp->dev == TWINCOMM2)
  1424.     {
  1425.         /* mode setup for this channel's driver timer */
  1426.         outportb(Twin_io_base+TMR_CTRL,(unsigned char)0xb0);
  1427.         nop;
  1428.         inportb(Twin_io_base+CLR_TMR2);
  1429.         nop;
  1430.         /* If the timer hasn't gone off, the hardware is either */
  1431.         /* not present, or broken... */
  1432.         if(!inportb(Twin_io_base+INT_REG) & 0x04)
  1433.         {
  1434.             restore(i_state);
  1435.             return(-1);
  1436.         }
  1437.         nop;
  1438.         /* Assert DTR to indicate we are alive...*/
  1439.         outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_DTRB_ON));
  1440.     }
  1441.  
  1442.     if(dcbp->dma_flg == TRUE)
  1443.     {
  1444.         /* mask off the DMA channel(s) */
  1445.         outportb(DMAWSMR,(dcbp->dma_rx_chan | 0x04));
  1446.         outportb(DMAWSMR,(dcbp->dma_tx_chan | 0x04));
  1447.  
  1448.         outportb(Twin_io_base+DMA_CLR_FF,0x00);    /* Initially clear the REQ's */    
  1449.                         /* This is the PackeTwin reg..*/
  1450.                         /* NOT the 8237 reg... */                    
  1451.         outportb(DMAMODE,dcbp->dma_rx_chan |  RX_DMA);
  1452.  
  1453.         if(dcbp->hduplex == FALSE)
  1454.         {
  1455.             outportb(DMAMODE,dcbp->dma_rx_chan |  RX_DMA);
  1456.             outportb(DMAMODE,dcbp->dma_tx_chan |  TX_DMA);
  1457.             /* tx dma, enabled, fdx, chan3*/
  1458.             /* rx dma, enabled, fdx, chan1*/
  1459.             outportb(Twin_io_base+DMA_CFG,dcbp->dma_tx_mode);
  1460.  
  1461.         }
  1462.         else
  1463.         {
  1464.             outportb(DMAMODE,dcbp->dma_rx_chan |  RX_DMA);
  1465.             /* rx dma,hdx, enabled, chan 1*/
  1466.             outportb(Twin_io_base+DMA_CFG,dcbp->dma_rx_mode);
  1467.         }
  1468.         outportb(DMAFFCL,0x00);        /* This is the 8237 reg */
  1469.  
  1470.         rxprime_dma(dcbp,1);        /* buglet... 9/12/92 */
  1471.                                     /* {dgl} */
  1472.     }
  1473.  
  1474.     /* reset Tx int pending */
  1475.     /* This should keep the chip from underrunning, as */
  1476.     /* well as clearing any pending txempty interrupt */
  1477.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = 0x28));
  1478.  
  1479.     /* reset external status latch */
  1480.     /* clear any pending ext sts bits */
  1481.     /* TWICE for good measure */
  1482.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = RES_EXT_INT));
  1483.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = RES_EXT_INT));
  1484.  
  1485.     /* Reset Underrun/EOM latch */
  1486.     /* clear the latch... it should stay that way...*/
  1487.     /* at least till we send feed some data to the tx fifo */
  1488.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = (RES_EOM_L | RES_EXT_INT)));
  1489.  
  1490.     /* Turn on DCD interrupt */
  1491.     Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 = CTSIE|DCDIE));
  1492.  
  1493.     /* save this initial state of RR0 */
  1494.      dcbp->extreg = Twin_read_scc(dcbp->zhwmap.ctl,R0);    
  1495.     dcbp->extreg = dcbp->extreg |= TxEOM;
  1496.  
  1497.     /* if we are interrupt driven only: then allow ints for ALL RCV cndxs,
  1498.     */
  1499.     if(dcbp->dma_flg == FALSE)
  1500.         Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0x13));
  1501.  
  1502.     /* otherwise interrupt on special rcv cdx only */
  1503.     /* DMA req mode Req on rcv, Req enabled */
  1504.     else  Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0xf9));
  1505.  
  1506.     /* master interrupt enable  the channel */
  1507.     Twin_write_scc(dcbp->zhwmap.ctl,R9,(dcbp->wr9 = (MIE|DLC|NV))); 
  1508.  
  1509.     restore(i_state);
  1510.     return(0);
  1511. }
  1512.  
  1513. void
  1514. tsync_loopback(dcbp,flag)
  1515. DCB     *dcbp;
  1516. char    flag;
  1517. {
  1518.     if(flag == ON)
  1519.     {
  1520.         switch(dcbp->dev)
  1521.         {
  1522.             case TWINCOMM1: outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_LOOPA_ON));
  1523.                                  break;
  1524.  
  1525.             case TWINCOMM2: outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg |= PKTWIN_LOOPB_ON));
  1526.                             break;
  1527.         }
  1528.     }
  1529.     else
  1530.     {
  1531.         switch(dcbp->dev)
  1532.         {
  1533.             case TWINCOMM1: outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_LOOPA_ON)));
  1534.                                      break;
  1535.  
  1536.             case TWINCOMM2: outportb(Twin_io_base+SERIAL_CFG,(Twin_sercfg &= (~PKTWIN_LOOPB_ON)));
  1537.                             break;
  1538.         }
  1539.     }
  1540.  
  1541. }
  1542.  
  1543.  
  1544. void
  1545. tsync_reset_8530()
  1546. {
  1547.  
  1548. int16    ctl;
  1549.  
  1550.     ctl = (int16)(Twin_io_base+SCCA_CMD);
  1551.     Twin_write_scc(ctl,R9,FHWRES);     
  1552.  
  1553. }
  1554.  
  1555. /*
  1556.           1         2         3         4         5         6         7
  1557. 01234567890123456789012345678901234567890123456789012345678901234567890123456789
  1558. /* 
  1559.  * Display a PackeTwin SYNCHRONOUS channel's internal state
  1560.  */
  1561. int
  1562. do_tsync_dump(argc,argv,p)
  1563. int argc;            
  1564. char *argv[];
  1565. void *p;                /* new for NOS */
  1566. {
  1567.     DCB *dcbp;
  1568.     UNI_DCB *udcbp;
  1569.     int16 dev;
  1570.     char    tmpstr[40];
  1571.  
  1572.     if(argc < 2)
  1573.     {
  1574.         tprintf("Usage: tsydump channel#\n");
  1575.         return 1;
  1576.     }
  1577.  
  1578.     dev = htoi(argv[1]);        /* get port number to look at */
  1579.  
  1580.     tprintf("                PackeTwin Synchronous Channel Internals\n\n");
  1581.  
  1582.     udcbp = &Twin_udcb[dev];
  1583.     if ( udcbp->type == SYNC_8530 )
  1584.     {
  1585.         if ( udcbp->attached == TRUE )
  1586.         {
  1587.             dcbp = (DCB *)udcbp->dcbp;
  1588.             tprintf("\n");
  1589.             tprintf(" RECEIVER STATUS: \n");
  1590.             tprintf(" Packcnt       Nqued     Bytecnt  Availcount      Nobufs\n");
  1591.             tprintf("%#8ld    %#8ld    %#8ld    %#8ld    %#8ld\n",
  1592.                             dcbp->rxpackcnt,dcbp->rxnqued,
  1593.                             dcbp->rxbytecnt,dcbp->rxavailcount,dcbp->nobufs);
  1594.  
  1595.             tprintf("\n");    /* blank line */
  1596.             tprintf(" Overcnt    Abortcnt   Crcerrcnt     Truncnt\n");
  1597.             tprintf("%#8ld    %#8ld    %#8ld    %#8ld\n",
  1598.                             dcbp->rxovercnt,dcbp->rxabortcnt,
  1599.                             dcbp->rxcrcerrcnt,dcbp->rxtruncnt);
  1600.  
  1601.             tprintf("\n");    /* blank line */
  1602.  
  1603.             switch(dcbp->txstate)
  1604.             {
  1605.                 case    IDLE:
  1606.                                 strcpy(tmpstr,"IDLE");
  1607.                                 break;
  1608.  
  1609.                 case    DEFER:
  1610.                                 strcpy(tmpstr,"DEFER");
  1611.                                 break;
  1612.  
  1613.                 case    TX_ACTIVE:
  1614.                                 strcpy(tmpstr,"TX_ACTIVE");
  1615.                                 break;
  1616.  
  1617.                 case    KEYED_UP:
  1618.                                 strcpy(tmpstr,"KEYED_UP");
  1619.                                 break;
  1620.  
  1621.                 case    CRCING:
  1622.                                 strcpy(tmpstr,"CRCING");
  1623.                                 break;
  1624.  
  1625.                 case    TX_KEYUP_DELAY:
  1626.                                     strcpy(tmpstr,"TX_KEYUP_DELAY");
  1627.                                     break;
  1628.  
  1629.                 case    TX_KEYDOWN_DELAY:
  1630.                                     strcpy(tmpstr,"TX_KEYDOWN_DELAY");
  1631.                                     break;
  1632.  
  1633.                 case    TX_PERSIST:
  1634.                                     strcpy(tmpstr,"TX_PERSIST");
  1635.                                     break;
  1636.  
  1637.                 case    TX_DONE:
  1638.                                 strcpy(tmpstr,"TX_DONE");
  1639.                                 break;
  1640.  
  1641.                 default:
  1642.                                 strcpy(tmpstr,"UNKNOWN STATE");
  1643.                                 break;
  1644.  
  1645.             }
  1646.  
  1647.             tprintf(" TRANSMITTER STATUS:\n");
  1648.             tprintf(" Packcnt     Bytecnt    Underrun    Cur_xbufp   Cur_xbytes  MxFIFO  TX STATE\n");
  1649.  
  1650.             tprintf("%8ld    %8ld    %8ld    %8lx    %8d      %2.2d    ",
  1651.                     dcbp->txpackcnt,dcbp->txbytecnt,
  1652.                     dcbp->txunderun,dcbp->cur_xbufp,
  1653.                     dcbp->cur_xbytes,dcbp->maxtxbytes);
  1654.             tprintf("%s\n",tmpstr);
  1655.  
  1656.             tprintf("\n");    /* blank line */
  1657.             tprintf(" CTSlost: %d\n",dcbp->txctslost);
  1658.             tprintf("\n");    /* blank line */
  1659.  
  1660.             tprintf( "WR0  WR1  WR2  WR3  WR4  WR5  WR6  WR7  WR8  WR9  WR10 WR11 WR12 WR13 WR14 WR15");
  1661.  
  1662.  
  1663.             tprintf(" %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x   %2.2x",
  1664.                     dcbp->wr0,dcbp->wr1,dcbp->wr2,dcbp->wr3,dcbp->wr4,
  1665.                     dcbp->wr5,dcbp->wr6,dcbp->wr7,0,dcbp->wr9,
  1666.                     dcbp->wr10,dcbp->wr11,dcbp->wr12,dcbp->wr13,dcbp->wr14,
  1667.                     dcbp->wr15);
  1668.  
  1669.             tprintf("\n");
  1670.             tprintf("\n");
  1671.  
  1672. tprintf("Extsts  Extreg  Hduplex  Dma_flg  Txclk_extrn  Rxclk_extrn  Nrzi_flg\n");
  1673.             tprintf("  %2.2x      %2.2x      %2.2x       %2.2x         %2.2x           %2.2x           %2.2x\n",
  1674.                     dcbp->extsts,dcbp->extreg,dcbp->hduplex,
  1675.                     dcbp->dma_flg,dcbp->txclk_extrn,
  1676.                     dcbp->rxclk_extrn,dcbp->nrzi_flg);
  1677.  
  1678.  
  1679.             tprintf("\n");
  1680.  
  1681.             tprintf("Dma_rx_chan  Dma_rx_mode  Dma_rx_pagereg  Dma_rx_cnt_reg  Dma_rx_addr_reg\n");
  1682.  
  1683.             tprintf( "    %2.2x           %2.2x           %2.2x              %2.2x              %2.2x\n",
  1684.                         dcbp->dma_rx_chan,dcbp->dma_rx_mode,
  1685.                         dcbp->dma_rx_pagereg,dcbp->dma_rx_cnt_reg,
  1686.                         dcbp->dma_rx_addr_reg);
  1687.  
  1688.             tprintf("Dma_tx_chan  Dma_tx_mode  Dma_tx_pagereg  Dma_tx_cnt_reg  Dma_tx_addr_reg\n");
  1689.             tprintf( "    %2.2x           %2.2x           %2.2x              %2.2x              %2.2x\n",
  1690.                         dcbp->dma_tx_chan,dcbp->dma_tx_mode,
  1691.                         dcbp->dma_tx_pagereg,dcbp->dma_tx_cnt_reg,
  1692.                         dcbp->dma_tx_addr_reg);
  1693.  
  1694.         }
  1695.         else tprintf("Channel %d: is UN-attached!\n",dev);
  1696.     }
  1697.         
  1698.  
  1699.     tprintf("\n");
  1700.     return(0);
  1701. }
  1702.  
  1703. /* 85230 Mods: Call this routine to enable the Deeper TX fifo... */
  1704. /* Do it BEFORE you set up WR7 (sync char), cause it will trash  */
  1705. /* WR7 if the installed chip is actually an 85c30 or 8530 instead*/
  1706. /* of an 85230 */
  1707. void
  1708. enable_escc(dcbp)
  1709. register DCB *dcbp;
  1710. {
  1711.  
  1712.     /* try to enable the escc extended registers */
  1713.     Twin_write_scc(dcbp->zhwmap.ctl,R15,0x01);
  1714.  
  1715.     /* Set up the TX FIFO to generate an interrupt as soon */
  1716.     /* as there is ANY room in the FIFO.  Rather than the default */
  1717.     /* of when the FIFO is empty. */
  1718.  
  1719.     /* If this is just an SCC, then the R7 will be overwritten */
  1720.     /* by the real init code later..., but if not, */
  1721.     /* then this is R7' for FIFO control */
  1722.     Twin_write_scc(dcbp->zhwmap.ctl,R7,0x00);
  1723.  
  1724.     /* restore the WR15 to an acceptable value for an 8530 */
  1725.     Twin_write_scc(dcbp->zhwmap.ctl,R15,0x00);
  1726. }    
  1727.